Building a Reminder or Scheduled Task Application

Course: iOS App Development

Topic: Building a Reminder or Scheduled Task Application

Course Link: iOS App Development Training

Demo Link: Register for Course Demo

Website: JustAcademy

1. Introduction to Reminder and Scheduled Task Applications

A reminder or scheduled task application is an iOS application that helps users organize daily activities, manage responsibilities, schedule important events, and receive notifications at specific times. These applications allow users to create tasks, assign due dates, set reminders, update task status, and receive alerts before deadlines.

In iOS development, reminder applications can be created using Swift, SwiftUI, UIKit, Core Data, UserNotifications, and other Apple frameworks.

Examples of reminder applications include:

• Daily task management applications.
• Study schedule and assignment reminder applications.
• Medicine reminder applications.
• Meeting and appointment scheduling applications.
• Personal productivity applications.
• Bill payment and subscription reminder applications.

Key Features

• Create, edit, and delete tasks.
• Set task priorities and categories.
• Choose dates and times for reminders.
• Schedule local notifications.
• Mark tasks as completed or pending.
• Display upcoming and overdue tasks.
• Store task information locally.
• Support repeating reminders.
• Provide an organized user interface.

2. Understanding the Application Architecture

A reminder application generally follows a structured architecture in which the user interface, business logic, data storage, and notification functionality are separated.

Main Application Components

Application Workflow

User Opens Application
        |
        v
Display Task Dashboard
        |
        v
Create New Reminder
        |
        v
Enter Task Details
        |
        v
Select Date and Time
        |
        v
Validate Task Information
        |
        v
Save Task in Local Database
        |
        v
Request Notification Permission
        |
        v
Schedule Local Notification
        |
        v
Display Scheduled Task
        |
        v
User Completes or Updates Task

3. Selecting Technologies and Frameworks

Several Apple frameworks can be combined to develop a complete reminder application.

4. Creating the Reminder Application Project in Xcode

The first step is to create a new iOS project in Xcode and configure the application structure.

Project Creation Steps

1. Open Xcode on macOS.
2. Select Create a New Xcode Project.
3. Choose the iOS platform.
4. Select the App template.
5. Enter the project name as TaskReminderApp.
6. Select Swift as the programming language.
7. Choose SwiftUI or UIKit as the interface technology.
8. Configure the project organization details.
9. Select a suitable iOS deployment target.
10. Create and run the project.

Suggested Project Structure

TaskReminderApp/
|
|-- Models/
|   |-- Task.swift
|
|-- Views/
|   |-- DashboardView.swift
|   |-- AddTaskView.swift
|   |-- TaskDetailView.swift
|
|-- ViewModels/
|   |-- TaskViewModel.swift
|
|-- Services/
|   |-- NotificationManager.swift
|   |-- PersistenceManager.swift
|
|-- Resources/
|
|-- TaskReminderApp.swift

5. Designing the Task Data Model

A task model defines the information that must be stored for every reminder. A well-designed model makes task management easier and supports future features such as categories, priorities, and recurring reminders.

Important Task Properties

Example: Creating Task.swift

import Foundation

struct Task: Identifiable, Codable {

    var id: UUID = UUID()

    var title: String
    var description: String

    var dueDate: Date

    var isCompleted: Bool = false

    var priority: String = "Medium"

    var category: String = "Personal"

    var notificationEnabled: Bool = true

    var createdAt: Date = Date()
}

The Identifiable protocol allows SwiftUI lists to identify individual tasks. The Codable protocol makes it possible to convert task objects into formats such as JSON for storage and retrieval.

6. Designing the Task Dashboard

The dashboard is the main screen of a reminder application. It displays the user's scheduled tasks and provides access to important task management operations.

Dashboard Components

• Application title and navigation bar.
• Task summary section.
• Upcoming reminders.
• Completed task count.
• Pending task count.
• Task category filters.
• Add new task button.
• Task list with completion controls.

Example: DashboardView.swift

import SwiftUI

struct DashboardView: View {

    @State private var tasks: [Task] = []

    var body: some View {

        NavigationStack {

            VStack {

                Text("My Reminders")
                    .font(.largeTitle)
                    .bold()

                Text("Organize your daily activities")
                    .foregroundColor(.secondary)

                List {

                    ForEach(tasks) { task in

                        HStack {

                            VStack(alignment: .leading) {

                                Text(task.title)
                                    .font(.headline)

                                Text(task.dueDate.formatted())
                                    .font(.caption)
                                    .foregroundColor(.secondary)
                            }

                            Spacer()

                            Image(
                                systemName: task.isCompleted
                                ? "checkmark.circle.fill"
                                : "circle"
                            )
                        }
                    }
                }

                NavigationLink("Add New Task") {
                    AddTaskView()
                }
                .padding()
            }
        }
    }
}

This example demonstrates the basic dashboard structure. In a complete application, the task array should be connected to a shared view model and persistent storage.

7. Creating the Add Reminder Screen

The Add Reminder screen allows users to enter task information and configure a schedule.

Required Input Fields

• Task title.
• Task description.
• Due date.
• Reminder time.
• Priority selection.
• Category selection.
• Notification enable or disable option.

Example: AddTaskView.swift

import SwiftUI

struct AddTaskView: View {

    @State private var title = ""
    @State private var description = ""

    @State private var dueDate = Date()

    @State private var priority = "Medium"

    @State private var notificationEnabled = true

    var body: some View {

        Form {

            Section("Task Details") {

                TextField("Task Title", text: $title)

                TextField(
                    "Description",
                    text: $description
                )
            }

            Section("Schedule") {

                DatePicker(
                    "Due Date",
                    selection: $dueDate,
                    displayedComponents: [.date, .hourAndMinute]
                )
            }

            Section("Priority") {

                Picker("Priority", selection: $priority) {

                    Text("Low").tag("Low")
                    Text("Medium").tag("Medium")
                    Text("High").tag("High")
                }
            }

            Section("Notifications") {

                Toggle(
                    "Enable Reminder",
                    isOn: $notificationEnabled
                )
            }

            Button("Save Task") {

                print("Task Title: \(title)")
            }
            .disabled(title.trimmingCharacters(
                in: .whitespacesAndNewlines
            ).isEmpty)
        }
        .navigationTitle("Add Reminder")
    }
}

The form provides a structured method for collecting reminder details. The save operation can be connected to a persistence manager and notification manager.

8. Implementing Task Creation and Validation

Task validation ensures that users cannot create incomplete or invalid reminders.

Common Validation Rules

• Task title must not be empty.
• Task title should have a reasonable character limit.
• Due date should be valid.
• Priority must match an available option.
• Duplicate tasks should be handled according to application requirements.
• Past dates should be validated when the task requires a future reminder.
• Notification scheduling should be optional.

Example: Task Validation Function

func validateTask(
    title: String,
    dueDate: Date
) -> Bool {

    let trimmedTitle = title.trimmingCharacters(
        in: .whitespacesAndNewlines
    )

    guard !trimmedTitle.isEmpty else {
        print("Task title is required")
        return false
    }

    guard trimmedTitle.count <= 100 else {
        print("Task title is too long")
        return false
    }

    guard dueDate > Date() else {
        print("Choose a future reminder time")
        return false
    }

    return true
}

Validation should be performed before saving the task or scheduling its notification. Applications may also support tasks without reminders, in which case the date validation should follow the application's business rules.

9. Implementing Local Notifications

Local notifications allow the reminder application to notify users when a scheduled task reaches its reminder time. The UserNotifications framework provides the necessary APIs.

Step 1: Import UserNotifications

import UserNotifications

Step 2: Request Notification Permission

func requestNotificationPermission() {

    let center = UNUserNotificationCenter.current()

    center.requestAuthorization(
        options: [.alert, .sound, .badge]
    ) { granted, error in

        if let error = error {
            print(error.localizedDescription)
            return
        }

        print("Permission granted: \(granted)")
    }
}

Step 3: Create Notification Content

func createContent(
    title: String,
    body: String
) -> UNMutableNotificationContent {

    let content = UNMutableNotificationContent()

    content.title = title
    content.body = body
    content.sound = .default

    return content
}

Step 4: Create a Calendar Trigger

func createCalendarTrigger(
    date: Date
) -> UNCalendarNotificationTrigger {

    let components = Calendar.current.dateComponents(
        [.year, .month, .day, .hour, .minute],
        from: date
    )

    return UNCalendarNotificationTrigger(
        dateMatching: components,
        repeats: false
    )
}

Step 5: Schedule the Notification

func scheduleReminder(
    task: Task
) {

    guard task.notificationEnabled else {
        return
    }

    guard task.dueDate > Date() else {
        return
    }

    let content = createContent(
        title: task.title,
        body: task.description
    )

    content.userInfo = [
        "taskID": task.id.uuidString
    ]

    let trigger = createCalendarTrigger(
        date: task.dueDate
    )

    let request = UNNotificationRequest(
        identifier: task.id.uuidString,
        content: content,
        trigger: trigger
    )

    UNUserNotificationCenter.current().add(request) {
        error in

        if let error = error {
            print("Scheduling error: \(error.localizedDescription)")
        } else {
            print("Reminder scheduled successfully")
        }
    }
}

Using the task UUID as the notification identifier makes it easier to connect a notification with its corresponding task and cancel it when necessary.

10. Implementing a Notification Manager

Instead of writing notification code in multiple screens, developers should create a reusable notification manager. It centralizes authorization, scheduling, and cancellation operations.

Example: NotificationManager.swift

import Foundation
import UserNotifications

final class NotificationManager {

    static let shared = NotificationManager()

    private let center = UNUserNotificationCenter.current()

    private init() {}

    func requestPermission(
        completion: @escaping (Bool) -> Void
    ) {

        center.requestAuthorization(
            options: [.alert, .sound, .badge]
        ) { granted, error in

            if let error = error {
                print(error.localizedDescription)
                completion(false)
                return
            }

            completion(granted)
        }
    }

    func schedule(
        task: Task
    ) {

        guard task.notificationEnabled,
              task.dueDate > Date() else {
            return
        }

        let content = UNMutableNotificationContent()

        content.title = task.title
        content.body = task.description
        content.sound = .default

        content.userInfo = [
            "taskID": task.id.uuidString
        ]

        let components = Calendar.current.dateComponents(
            [.year, .month, .day, .hour, .minute],
            from: task.dueDate
        )

        let trigger = UNCalendarNotificationTrigger(
            dateMatching: components,
            repeats: false
        )

        let request = UNNotificationRequest(
            identifier: task.id.uuidString,
            content: content,
            trigger: trigger
        )

        center.add(request) { error in

            if let error = error {
                print(error.localizedDescription)
            }
        }
    }

    func cancel(taskID: UUID) {

        center.removePendingNotificationRequests(
            withIdentifiers: [taskID.uuidString]
        )
    }

    func cancelAll() {

        center.removeAllPendingNotificationRequests()
    }
}

11. Implementing Task Management Using a ViewModel

The ViewModel manages application data and coordinates operations between the user interface, persistence layer, and notification manager.

Responsibilities of TaskViewModel

• Maintain the list of tasks.
• Add new reminders.
• Update existing reminders.
• Delete selected tasks.
• Mark tasks as completed.
• Schedule notifications.
• Cancel notifications when tasks are deleted or completed.
• Refresh the dashboard after changes.

Example: TaskViewModel.swift

import Foundation
import SwiftUI

@MainActor
final class TaskViewModel: ObservableObject {

    @Published var tasks: [Task] = []

    func addTask(_ task: Task) {

        tasks.append(task)

        NotificationManager.shared.schedule(
            task: task
        )
    }

    func completeTask(_ task: Task) {

        guard let index = tasks.firstIndex(
            where: { $0.id == task.id }
        ) else {
            return
        }

        tasks[index].isCompleted = true

        NotificationManager.shared.cancel(
            taskID: task.id
        )
    }

    func deleteTask(_ task: Task) {

        tasks.removeAll {
            $0.id == task.id
        }

        NotificationManager.shared.cancel(
            taskID: task.id
        )
    }

    func pendingTasks() -> [Task] {

        tasks.filter {
            !$0.isCompleted
        }
    }

    func completedTasks() -> [Task] {

        tasks.filter {
            $0.isCompleted
        }
    }
}

This ViewModel demonstrates basic task operations. Persistent storage should be added so that task information remains available after the application is closed.

12. Storing Tasks Using UserDefaults

UserDefaults can store small amounts of simple application data. For a basic reminder application, Codable task objects can be encoded into JSON data and stored locally.

Example: Saving Tasks

func saveTasks(_ tasks: [Task]) {

    do {

        let data = try JSONEncoder().encode(tasks)

        UserDefaults.standard.set(
            data,
            forKey: "savedTasks"
        )

        print("Tasks saved successfully")

    } catch {

        print("Saving error: \(error.localizedDescription)")
    }
}

Example: Loading Tasks

func loadTasks() -> [Task] {

    guard let data = UserDefaults.standard.data(
        forKey: "savedTasks"
    ) else {
        return []
    }

    do {

        return try JSONDecoder().decode(
            [Task].self,
            from: data
        )

    } catch {

        print("Loading error: \(error.localizedDescription)")
        return []
    }
}

UserDefaults is suitable for small, simple datasets. For larger applications with complex relationships, searching, filtering, and more advanced persistence requirements, Core Data or SwiftData is generally a better choice.

13. Integrating Core Data for Persistent Storage

Core Data provides an object graph and persistence framework for managing structured application data. It is useful when a reminder application needs reliable storage and more complex task management.

Core Data Implementation Steps

1. Create a Core Data model file.
2. Add a TaskEntity entity.
3. Create attributes such as id, title, description, dueDate, isCompleted, and priority.
4. Configure the persistent container.
5. Insert new task records.
6. Fetch tasks using NSFetchRequest.
7. Update task properties.
8. Delete completed or unwanted tasks.
9. Save changes using the managed object context.

Example: Saving a Task with Core Data

func saveTask(
    title: String,
    dueDate: Date,
    context: NSManagedObjectContext
) {

    let newTask = TaskEntity(context: context)

    newTask.id = UUID()
    newTask.title = title
    newTask.dueDate = dueDate
    newTask.isCompleted = false

    do {

        try context.save()

        print("Task stored successfully")

    } catch {

        print("Core Data error: \(error.localizedDescription)")
    }
}

14. Implementing Task Completion and Status Management

A reminder application should allow users to update the status of tasks. Common statuses include Pending, Completed, Overdue, and Scheduled.

Task Status Types

Example: Checking Overdue Tasks

func isOverdue(_ task: Task) -> Bool {

    return !task.isCompleted &&
           task.dueDate < Date()
}

Example: Marking a Task Completed

func markCompleted(_ task: inout Task) {

    task.isCompleted = true

    NotificationManager.shared.cancel(
        taskID: task.id
    )
}

When a task is completed, its pending reminder should generally be cancelled to avoid unnecessary notifications.

15. Implementing Task Categories and Priorities

Categories and priorities help users organize reminders according to their importance and purpose.

Suggested Task Categories

• Personal.
• Work.
• Education.
• Health.
• Shopping.
• Finance.

Priority Levels

Example: Filtering Tasks by Priority

func filterTasks(
    tasks: [Task],
    priority: String
) -> [Task] {

    return tasks.filter {
        $0.priority == priority
    }
}

16. Implementing Repeating Reminders

Some tasks must repeat daily, weekly, or according to a custom schedule. Examples include taking medicine, exercising, attending regular meetings, and completing daily study sessions.

The UNCalendarNotificationTrigger supports repeating calendar-based notifications.

Example: Daily Repeating Reminder

func scheduleDailyReminder(
    title: String,
    body: String,
    hour: Int,
    minute: Int
) {

    let content = UNMutableNotificationContent()

    content.title = title
    content.body = body
    content.sound = .default

    var components = DateComponents()

    components.hour = hour
    components.minute = minute

    let trigger = UNCalendarNotificationTrigger(
        dateMatching: components,
        repeats: true
    )

    let request = UNNotificationRequest(
        identifier: UUID().uuidString,
        content: content,
        trigger: trigger
    )

    UNUserNotificationCenter.current().add(request)
}

Example: Weekly Reminder

var components = DateComponents()

components.weekday = 2
components.hour = 10
components.minute = 0

let trigger = UNCalendarNotificationTrigger(
    dateMatching: components,
    repeats: true
)

In the Gregorian calendar, weekday value 2 represents Monday. Calendar conventions should be considered when configuring recurring schedules.

17. Editing and Rescheduling Existing Reminders

Users should be able to modify reminder details when their schedules change. Editing a reminder generally involves updating the stored task and replacing its pending notification request.

Rescheduling Workflow

1. Identify the task using its unique ID.
2. Load the existing task information.
3. Allow the user to edit the title or description.
4. Update the due date and time.
5. Save the updated task in persistent storage.
6. Remove the old pending notification.
7. Schedule a new notification using the same identifier.

Example: Updating a Reminder

func rescheduleReminder(
    task: Task
) {

    let center = UNUserNotificationCenter.current()

    center.removePendingNotificationRequests(
        withIdentifiers: [task.id.uuidString]
    )

    NotificationManager.shared.schedule(
        task: task
    )
}

Using the same notification identifier helps prevent multiple active requests for the same reminder.

18. Handling Notification Permissions and Errors

Notification authorization is controlled by the user. A reminder application must handle situations in which notification permission is not determined, denied, provisional, or authorized.

Authorization Statuses

Example: Checking Authorization

func checkNotificationSettings() {

    UNUserNotificationCenter.current()
        .getNotificationSettings { settings in

        switch settings.authorizationStatus {

        case .authorized:
            print("Notifications enabled")

        case .denied:
            print("Notifications disabled")

        case .notDetermined:
            print("Permission not requested")

        case .provisional:
            print("Provisional authorization")

        case .ephemeral:
            print("Temporary authorization")

        @unknown default:
            print("Unknown status")
        }
    }
}

19. Implementing Search and Filtering

As the number of reminders increases, users need search and filtering functionality to locate specific tasks quickly.

Useful Filtering Options

• All tasks.
• Today's tasks.
• Upcoming tasks.
• Completed tasks.
• Overdue tasks.
• High-priority tasks.
• Tasks grouped by category.

Example: Searching Tasks

func searchTasks(
    tasks: [Task],
    searchText: String
) -> [Task] {

    guard !searchText.isEmpty else {
        return tasks
    }

    return tasks.filter {

        $0.title.localizedCaseInsensitiveContains(
            searchText
        )
    }
}

Example: Getting Today's Tasks

func todaysTasks(
    tasks: [Task]
) -> [Task] {

    return tasks.filter {

        Calendar.current.isDateInToday(
            $0.dueDate
        )
    }
}

20. Managing Application Lifecycle and Notification Delivery

Reminder applications must handle changes in application state, including foreground, background, and terminated states. Local notifications can be delivered by the operating system even when the application is not actively running, subject to system behavior and notification settings.

Important Considerations

• Schedule notification requests before the application enters the background.
• Do not depend on the application remaining active until the reminder time.
• Use notification delegate methods to handle foreground presentation and user interactions.
• Refresh task information when the application becomes active.
• Synchronize task completion and notification cancellation.
• Do not assume that a notification will always produce a visible banner.

Example: Refreshing Data When the App Becomes Active

import SwiftUI

struct ReminderDashboard: View {

    @Environment(\.scenePhase) private var scenePhase

    var body: some View {

        Text("Reminder Dashboard")
            .onChange(of: scenePhase) { _, newPhase in

                if newPhase == .active {

                    print("Application became active")

                    // Refresh task information here.
                }
            }
    }
}

21. Testing the Reminder Application

Testing ensures that task creation, data storage, scheduling, notification delivery, and task updates work correctly.

Functional Testing

Testing Steps

1. Run the application in an iOS Simulator or on a physical iPhone.
2. Create a new task with a future due time.
3. Enable notification permission.
4. Verify that the task is saved.
5. Move the application into the background.
6. Wait for the scheduled notification.
7. Open the notification and verify the expected interaction.
8. Mark the task as completed.
9. Verify that the pending notification is cancelled.
10. Restart the application and confirm that task data is retained.

22. Common Development Problems and Solutions

23. Best Practices for Building Reminder Applications

• Use a clean and intuitive interface.
• Separate views, models, view models, and service classes.
• Use unique identifiers for tasks and notifications.
• Validate reminder information before saving.
• Use persistent storage for important task data.
• Request notification permission at an appropriate moment.
• Cancel notifications when reminders are deleted or completed.
• Reschedule notifications whenever their date or time changes.
• Support task filtering and priority management.
• Handle time zone and calendar changes carefully.
• Provide useful error messages.
• Test on multiple supported iOS versions.
• Avoid scheduling unnecessary notifications.
• Protect sensitive task information.
• Keep the application responsive when managing large task lists.

24. Practical Project: Daily Reminder and Task Scheduler

Develop a complete reminder application that allows users to organize their daily activities and receive scheduled notifications.

Project Objectives

• Create a modern dashboard using SwiftUI.
• Build an Add Reminder form.
• Allow users to select task dates and times.
• Implement notification authorization.
• Schedule local notifications.
• Store task information using Core Data or SwiftData.
• Implement task editing and deletion.
• Support completed, pending, and overdue statuses.
• Provide category and priority filters.
• Implement recurring reminders.
• Support notification cancellation and rescheduling.

Expected Screens

Expected Learning Outcomes

After completing this project, learners will understand how to design an iOS task management interface, create reusable Swift models, manage application state, implement local persistence, schedule notifications, and handle complete task management workflows.

25. Interview Questions and Answers

Q1. What is a reminder application in iOS?

Answer: A reminder application allows users to create tasks, set deadlines, schedule alerts, and manage daily activities using iOS technologies.

Q2. Which framework is used for local notifications?

Answer: The UserNotifications framework is used to request permission, create notification content, schedule reminders, and handle notification interactions.

Q3. What is the purpose of a Task Model?

Answer: A task model defines the properties of a reminder, including its ID, title, description, due date, priority, and completion status.

Q4. Why is persistent storage important?

Answer: Persistent storage ensures that task information remains available even after the application is closed or the device is restarted.

Q5. What is the difference between UserDefaults and Core Data?

Answer: UserDefaults is intended for small preference values and simple data, whereas Core Data supports structured object storage, relationships, fetching, and more complex data management.

Q6. What is UNCalendarNotificationTrigger?

Answer: It schedules notifications according to calendar components such as year, month, day, hour, and minute.

Q7. How can duplicate notifications be prevented?

Answer: Use stable and unique notification identifiers. Before replacing a scheduled reminder, remove the old pending request and schedule the updated request.

Q8. How do you cancel a notification?

Answer: Use the removePendingNotificationRequests(withIdentifiers:) method with the relevant notification identifier.

Q9. How can overdue tasks be identified?

Answer: Compare the task's due date with the current date and verify that the task has not been marked completed.

Q10. What is the purpose of a ViewModel?

Answer: A ViewModel separates interface-related state and business logic from the user interface, making the application easier to maintain and test.

Q11. How can a reminder be rescheduled?

Answer: Update the task's due date, cancel its previous notification request, and schedule a new notification using the same identifier.

Q12. Can local notifications work without internet connectivity?

Answer: Yes. Local notifications are scheduled on the device and do not require an internet connection for normal delivery.

Q13. What is the purpose of SwiftUI's @Published property?

Answer: It publishes changes to observable properties so that dependent SwiftUI views can update when the data changes.

Q14. How can recurring reminders be implemented?

Answer: Use UNCalendarNotificationTrigger with repeating calendar components such as hour, minute, or weekday.

Q15. What happens when notification permission is denied?

Answer: The application should continue to support task management without notification delivery and provide an option to open application settings.

26. Practical Exercises

1. Create a basic reminder application using SwiftUI.
2. Build a form for entering task details.
3. Add a date and time picker.
4. Implement notification authorization.
5. Schedule a notification for a future task.
6. Store tasks using UserDefaults.
7. Implement task persistence using Core Data.
8. Build task completion and deletion functionality.
9. Implement task search and filtering.
10. Add high, medium, and low priority levels.
11. Create daily and weekly recurring reminders.
12. Implement notification cancellation and rescheduling.
13. Build a dashboard displaying pending and completed tasks.
14. Test notification behavior when the application is in the background.

27. Quick Revision

28. Conclusion

Building a reminder or scheduled task application is an important practical project in iOS application development. It combines Swift programming, SwiftUI interface design, data modeling, persistent storage, application state management, and local notification scheduling.

By developing this application, learners gain experience creating real-world productivity features such as task creation, deadline management, recurring reminders, notification permissions, task completion, and data persistence.

A well-structured reminder application provides a strong foundation for developing more advanced iOS applications involving calendars, productivity tools, appointment management, and personal scheduling systems.

Learn iOS App Development with JustAcademy

Explore professional iOS App Development training and learn Swift, SwiftUI, UIKit, Core Data, APIs, local notifications, application lifecycle management, and real-world iOS projects.

Explore the Course: iOS App Development Training

Register for a Free Demo: Book Your Course Demo

Visit JustAcademy: JustAcademy Official Website